import java.sql.SQLOutput;

/*
 *Description:
 *User:laoHu
 *Created with Intellij IDEA 2025
 *Data:2025.06.28
 *Time:22:45
 */
//非泛型
class Test{
    Object[] arrays = new Object[10];

    //方法
    void setArrays(int pos ,Object val){
        arrays[pos] = val;
    }
    public  Object  getArrays(int pos){
        return arrays[pos];
    }
}
//泛型
class Test1<E>{//E表示Element 元素
    Object[] arrays = new Object[10];

    //方法
    void setArrays(int pos ,E val){
        arrays[pos] = val;
    }
    //返回类型是E
    public  E  getArrays(int pos){
        return (E)arrays[pos];//应为arrays引用的类型是Object需要强制类型转换
    }
}
//泛型的上界
class Test3<E extends Number>{}//在Number类和Number子类的范围
//实现Comparable接口
class Test4<E extends Comparable<E>>{

    public  E MaxNum(E[] arrays){
        E max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(max.compareTo(arrays[i])< 0)
               max = arrays[i];
        }
        return max;
    }

}
public class Main{
    public static void main(String[] args) {
        Integer[] a = {1,2,3,4,5};
        Test4<Integer> test4 = new Test4<>();
        int x = test4.MaxNum(a);
        System.out.println(x);
    }

    //擦除机制：在编译时将泛型转换，输出时不具体输出类型
    public static void main3(String[] args) {
        Test test = new Test();
        Test1<String> test1 = new Test1<String>();

        System.out.println(test);//输出类名Test+ @ + 地址
        System.out.println(test1);//输出类名，不输出具体类型String + @ + 地址

    }
    //泛型
    public static void main2(String[] args) {
        //实例化时指定指定类型,类型不能是基本数据类型int or byte
        Test1<Integer> test1 = new Test1<Integer>();
        test1.setArrays(0,10);
        int c = test1.getArrays(0);//E类型换擦除为Integer
        System.out.println(c);
    }

    //非泛型
    public static void main1(String[] args) {
        Test test = new Test();
        //即定义了整型又定义了String类型
        test.setArrays(0,10);
        test.setArrays(1,"sss");
    }

    //oj复杂度：语句执行最多的次数，使用大O记录
    //常数部分删除 x +10 -> x
    //取最高阶 x^2 +x -> x
    //去除最高阶的常数项 ： 1/2 x^2 -> x^2

    //循环的OJ复杂度
    //test1的OJ复杂度是O（1）
    public void test1(){
        int cnt =0;
        for (int i = 0; i < 10;i++){
            cnt++;
        }
    }
    //test2的OJ复杂度是O(N)
    public void test2(int n){
        int i = 0;
        for(;i<n;i++){
            ;
        }
    }
    //test3的OJ复杂度是O(N^2)
    public void test3(int n){
        int i = 0;
        for (;i<n;i++){
            int j = 0;
            for(;j<n;j++){
                ;
            }
        }
    }
    //冒泡排序:最好的排序是arrays.length就是O(N)
    //但是OJ复杂度计算的是最坏结果：第一次是N -1 第二次是N-2
    //最后以此就是1 -》 1 + 2 + 3 + --- + N -》 （n-1 + 1 ）*n -1 /2
    // -> n^2/2 - n/2   -> n^2
    public void BubbleSort(int[] arrays){
        int i = 0;
        for (;i < arrays.length - 1;i++){
            boolean flat = true;
            int j = 0;
            for (;j < arrays.length - 1 - i; j++){
                if(arrays[j] > arrays[j+1]){
                    int tem = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = tem;
                    flat =false;
                }
            }
            if( flat == true) break;
        }
    }
    //二分查找:OJ复杂度是O(log N )
    //第一次查找范围n  第二次查找范围为 n/2 第x次后范围是1
    //及(n )/2^x = 1 x = log2(n); -> lon N
    //假设个数是N 第一次是1 第二次是 2 - 第N次是 2^(n-1) -》 2^(n-1) = N
    //n - 1 = log(N) n =log(N) - 1;
    public int BinarySort(int[] arrays,int target){
        int left = 0;
        int right = arrays.length - 1;
        while(left < right){
            int mid = (left + right)/2;
            if(arrays[mid] < target) {
                left = mid + 1;
            }else if(arrays[mid] > target){
                right = mid - 1;
            }else return mid;
        }
        return -1;
    }

}
